package cn.mujiankeji.mbrowser.界面.标签页.搜索引擎

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import cn.mujiankeji.mbrowser.app.应用接口
import cn.mujiankeji.mbrowser.工具.mlog
import cn.mujiankeji.mbrowser.数据.数据库.AppDatabase
import cn.mujiankeji.mbrowser.数据.数据库.DBSearchEngine
import cn.mujiankeji.mbrowser.数据.数据库.搜索引擎项目
import cn.mujiankeji.mbrowser.界面.框架.主视图.标签页状态
import io.github.vinceglb.filekit.FileKit
import io.github.vinceglb.filekit.dialogs.FileKitMode
import io.github.vinceglb.filekit.dialogs.FileKitType
import io.github.vinceglb.filekit.dialogs.openFilePicker
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.launch
import org.koin.core.context.GlobalContext
import java.util.UUID
import cn.mujiankeji.mbrowser.app.应用操作.应用搜索引擎操作
import cn.mujiankeji.mbrowser.数据.配置项.应用配置
import io.github.vinceglb.filekit.PlatformFile
import io.github.vinceglb.filekit.dialogs.openFileSaver
import io.github.vinceglb.filekit.readString
import io.github.vinceglb.filekit.size
import io.github.vinceglb.filekit.write
import io.github.vinceglb.filekit.writeString
import java.io.IOException

class 搜索引擎编辑状态(val db : AppDatabase = GlobalContext.get().get())
    : 标签页状态() {
    // 当前编辑的搜索引擎
    var 当前编辑引擎 by mutableStateOf(DBSearchEngine())
    
    // 是否是新建的搜索引擎
    var 是新建 by mutableStateOf(true)

    override val 标题 = MutableStateFlow<String?>("编辑引擎")

    var coroutine : CoroutineScope ?= null

    // 子引擎项目临时列表（用于编辑）
    val 子引擎项目列表 = mutableStateListOf<搜索引擎项目动态>()

    fun 保存(){
        coroutine?.launch {
            if (当前编辑引擎.名称.isEmpty()){
                应用接口.输出提示("保存失败，名称不可为空")
            }
            else{
                生成修改().let {
                    if (it.id == 0L){
                        db.搜索引擎().插入搜索引擎(it)
                    }else{
                        db.搜索引擎().更新搜索引擎(it)
                    }
                }
                应用接口.输出提示("保存成功")
            }
        }
    }
    suspend fun 生成修改() : DBSearchEngine{
        当前编辑引擎.地址列表.clear()
        子引擎项目列表.forEach {
            当前编辑引擎.地址列表.add(搜索引擎项目(
                名称 = it.名称,
                地址 = it.地址,
                POST = it.POST,
                编码 = it.编码
            ))
        }
        当前编辑引擎.引擎数量 = 当前编辑引擎.地址列表.size
        return 当前编辑引擎
    }

    fun 导入(){
        coroutine?.launch {
            try {
                val result = FileKit.openFilePicker(mode = FileKitMode.Single, type = FileKitType.File("txt"))
                    ?: throw IOException("未选择文件")

                if (result.size() > 1024 * 1024 * 2) throw IOException("导入文件过大")

                应用搜索引擎操作.解析对象(result.readString())
                    ?.also {
                        it.id = 当前编辑引擎.id
                    }
                    ?.also {
                        当前编辑引擎 = it
                        初始化编辑状态()
                    }

            } catch (e: Exception) {
                mlog("导入异常", e)
                应用接口.输出提示("导入失败: ${e.message}")
            }
        }
    }

    fun 导出(){
        coroutine?.launch {
            try {
                val json = 应用搜索引擎操作.格式化对象(生成修改())?:throw IOException("生成应用失败")
                val file = FileKit.openFileSaver(suggestedName = 当前编辑引擎.名称, extension =  "txt"
                , directory = PlatformFile(应用配置.路径_下载)) ?: return@launch // 没导出
                file.writeString(json)
                应用接口.输出提示("导出成功 ${file}")
            }catch (e : Exception){
                应用接口.输出提示("导出失败 ${e.message}")
            }
        }
    }

    fun 删除(){
       coroutine?.launch {
           if (当前编辑引擎.id != 0L){
               db.搜索引擎().删除搜索引擎(当前编辑引擎)
           }

           应用接口.界面模块().后退()
       }
    }

    fun 创建子引擎(){
        子引擎项目列表.add(搜索引擎项目动态()
            .apply {
                展开 = true
            })

    }


    // 删除子引擎
    fun 删除子引擎(索引: Int) {
        if (索引 >= 0 && 索引 < 子引擎项目列表.size) {
            子引擎项目列表.removeAt(索引)
            当前编辑引擎.引擎数量 = 子引擎项目列表.size
        }
    }


    init {
        初始化编辑状态()
    }


    fun 初始化编辑状态(){
        当前编辑引擎.名称
        当前编辑引擎.说明 ?: ""
        子引擎项目列表.clear()
        当前编辑引擎.地址列表.forEach {
            子引擎项目列表.add(搜索引擎项目动态(it))
        }
        if (子引擎项目列表.size == 0){
            子引擎项目列表.add(搜索引擎项目动态().apply {
                展开 = true
            })
        }
        当前编辑引擎.引擎数量 = 子引擎项目列表.size
        标题.value = if (是新建) "新建搜索引擎" else "编辑搜索引擎"
    }
}


class 搜索引擎项目动态{
    var 名称 by  mutableStateOf("")
    var 地址 by mutableStateOf("")
    var POST by mutableStateOf("")
    var 编码 by mutableStateOf("")
    var 展开 by mutableStateOf(false)
    val uuid = UUID.randomUUID().toString()
    constructor(){}
    constructor(项目 : 搜索引擎项目){
        this.名称 = 项目.名称
        this.地址 = 项目.地址
        this.POST = 项目.POST?:""
        this.编码 = 项目.编码?:""
    }
}